package com.linzm.leetcode.primary.exercises4_20230129;

import java.util.Arrays;
import java.util.Comparator;
import java.util.TreeSet;

/**
 * @Author zimingl
 * @Date 2023/2/9 23:58
 * @Description: 找到最近的有相同 X 或 Y 坐标的点
 * 给你两个整数 x 和 y ，表示你在一个笛卡尔坐标系下的 (x, y) 处。同时，在同一个坐标系下给你一个数组 points ，其中 points[i] = [ai, bi] 表示在 (ai, bi) 处有一个点。当一个点与你所在的位置有相同的 x 坐标或者相同的 y 坐标时，我们称这个点是 有效的 。
 * 请返回距离你当前位置 曼哈顿距离 最近的 有效 点的下标（下标从 0 开始）。如果有多个最近的有效点，请返回下标 最小 的一个。如果没有有效点，请返回 -1 。
 * 两个点 (x1, y1) 和 (x2, y2) 之间的 曼哈顿距离 为 abs(x1 - x2) + abs(y1 - y2) 。
 * <p>
 * 输入：x = 3, y = 4, points = [[1,2],[3,1],[2,4],[2,3],[4,4]]
 * 输出：2
 * 解释：所有点中，[3,1]，[2,4] 和 [4,4] 是有效点。有效点中，[2,4] 和 [4,4] 距离你当前位置的曼哈顿距离最小，都为 1 。[2,4] 的下标最小，所以返回 2 。
 */
public class Demo18_1779 {
    public static void main(String[] args) {
        Demo18_1779 demo18_1779 = new Demo18_1779();
        int x = 3, y = 4;
        int[][] points = {{1,2},{3,1},{2,4},{2,3},{4,4}};
        int i = demo18_1779.nearestValidPoint(x, y, points);
        System.out.println(i);
    }
    public int nearestValidPoint(int x, int y, int[][] points) {
        int min = Integer.MAX_VALUE;
        for (int i = 0; i < points.length; i++) {
            if ((points[i][0] == x && points[i][1] == y)) {
                min = Integer.MAX_VALUE - 1;
                continue;
            }
            if (points[i][0] == x || points[i][1] == y) {
                int m = Math.abs(points[i][0] - x) +  Math.abs(points[i][1] - y);
                min = Math.min(min, m);
            }
        }
        TreeSet<Integer> set = new TreeSet<>();
        for (int i = 0; i < points.length; i++) {
            int m = Math.abs(points[i][0] - x) +  Math.abs(points[i][1] - y);
            if ((points[i][0] == x || points[i][1] == y) && m == min) {
                set.add(points[i][0]);
                set.add(points[i][1]);
            }
        }
        if (min == Integer.MAX_VALUE) {
            return -1;
        }
        if (min == Integer.MAX_VALUE - 1) {
            return 0;
        }
        if (set.first() == x || set.first() == y) {
            return 0;
        }
        return set.first();
    }

    public int nearestValidPoint2(int x, int y, int[][] points) {
        return Arrays.asList(points).indexOf(
                Arrays.stream(points)
                        .filter(p -> p[0] == x || p[1] == y)
                        .min(Comparator.comparingInt(p -> (int) Math.sqrt(Math.pow(p[0] - x, 2) + Math.pow(p[1] - y, 2))))
                        .orElse(null)
        );
    }
}
